    //The Bind Pose Matrices allow a raw vertex of the mesh (in local coordinates) to be transformed into world-space
    // and then to each bone's local coordinate space, after which each bone's animation can be applied to the vertex in question
    // (under the influence of the weighting value). The mesh's bind pose takes the vertex from local space to world-space,
    // and then each bone's inverse bind pose takes the mesh vertex from world-space to the local space of that bone.
    // Once in the bone's local space, the bone's current animated transformation matrix is used to transform (deform)
    // the vertex's location. After all the bone influences have been taken into account, the vertex ends up in world-space
    // in its final deformed location. In other words, these bind pose matrices relate the location of a vertex in its local mesh space
    // to the same location of the vertex relative to each bones' local coordinate systems.
     
    // The mesh's Bind Pose Matrix takes its vertices into world-space, to the location at the time of binding,
    // and each bones' Bind Pose Matrix takes the bones from local space to world-space at the time of binding.
     
    function Start ()
    {
    gameObject.AddComponent(SkinnedMeshRenderer);
    var renderer : SkinnedMeshRenderer = GetComponent(SkinnedMeshRenderer);
     
    // Build basic mesh
    var mesh : Mesh = new Mesh ();
     
    mesh.vertices = [   Vector3(-1, 0, 0),
                        Vector3(1, 0, 0),
                        Vector3(-1, 5, 0),
                        Vector3(1, 5, 0)
                    ];
                   
    mesh.uv =       [    Vector2(0, 0),
                         Vector2(1, 0),
                         Vector2(0, 1),
                         Vector2(1, 1)
                    ];
               
    mesh.triangles = [   0, 1, 2,
                         1, 3, 2,
                         2, 1, 0,
                         2, 3, 1
                     ];
                   
    mesh.RecalculateNormals();
     
    // Assign mesh to mesh filter & renderer
     
    renderer.material = new Material (Shader.Find(" Diffuse"));
     
    // BoneWeight[4] : 4 = vertices 0 to 3
    // weights[0] : first (0) vertice
    // boneIndex0 : 0 = first bone
    // weight0 = 1 : 1 = how much influence this bone has on the vertice
     
    var weights = new BoneWeight[4];
     
    weights[0].boneIndex0 = 0;
    weights[0].weight0 = 1;
     
    weights[1].boneIndex0 = 0;
    weights[1].weight0 = 1;
     
    weights[2].boneIndex0 = 0;
    weights[2].weight0 = 1;
     
    weights[3].boneIndex0 = 0;
    weights[3].weight0 = 1;
     
    mesh.boneWeights = weights;
     
    // Create 1 Bone Transform and 1 Bind pose
     
    var bones : Transform[] = new Transform[1];
    var bindPoses : Matrix4x4[] = new Matrix4x4[1];
     
    // Create a new gameObject
     
    bones[0] = new GameObject ("Lower").transform;
     
    // Make this gameObject's transform the parent of the bone
     
    bones[0].parent = transform;
     
    // Set the position/rotation of the bone
     
    bones[0].localRotation = Quaternion.identity;
    bones[0].localPosition = Vector3.zero;
     
    // bones[0] is a Transform mapped to world space. We map it to the local space of its parent,
    // which is the transform "bones[0].worldToLocalMatrix" and afterwards
    // we map it again in world space, keeping the relation child - parent with "* transform.localToWorldMatrix;",
    // thus allowing us 1. to move/rotate/scale it freely in space but also
    //                            2. make all move/rotate/scaling operations on its parent affect it too
     
    bindPoses[0] = bones[0].worldToLocalMatrix * transform.localToWorldMatrix;
     
    // Apply bindPoses to the mesh
     
    mesh.bindposes = bindPoses;
     
    // Assign bones and bind poses to the SkinnedMeshRenderer
     
    renderer.bones = bones;
    renderer.sharedMesh = mesh;
    }